﻿//#define _CRT_SECURE_NO_WARNINGS  1
////一定要动手，例子不管多么简单，建议至少自己手敲一遍看看是否理解了里头的细枝末节。
////一定要学会思考，思考为什么要这样，而不是那样。还要举一反三地思考
//#include"string 模拟实现.h"
//namespace jz {
//	string::string(const char* str )
//	{
//		this->_size = strlen(str);
//		this->_capacity = this->_size;
//		this->_str = new char[_capacity + 1];
//		strcpy(this->_str, str);
//	}
//	/*~string()
//	{
//		delete[] _str;
//		this->_str = nullptr;
//		this->_capacity = 0;
//		this->_size = 0;
//	}*/
//	//实现深拷贝
//	string::string(const string& s)
//	{
//		//首先开辟空间
//		char* tem = new char[s._capacity + 1];
//		//拷贝数据
//		strcpy(tem,s._str);
//		//释放旧空间
//		delete[] _str;
//		_str = tem;
//		_capacity = s._capacity;
//		_size = s._size;
//	}
//	string::~string()
//	{
//		delete[] _str;
//		_str = nullptr;
//		_size = 0;
//		_capacity = 0;
//	}
//	
//	size_t string::size() const
//	{
//		return this->_size;
//	}
//	typedef char* iterator;			//dypedef 后要加分号
//	typedef const char* const_iterator;
//
//	const char& string::operator[](const size_t pos)const //修饰的是this指针指向的内容
//	{
//		assert(pos < this->_size);
//		return *(this->_str + pos);
//	}
//	char& string::operator[](const size_t pos)
//	{
//		assert(pos < this->_size);
//		return *(this->_str + pos);
//	}
//	void string::reserve(size_t n)
//	{
//		if (n > _capacity)	//当实际开辟的空间大于原空间是才开辟空间
//		{
//			////开辟空间
//			//char* tem = new char[n + 1];
//			//strcpy(tem, _str);
//			//delete[] _str;
//			//_str = tem;
//			//_capacity = n;
//			if (n > _capacity)
//			{
//				char* tmp = new char[n + 1];
//				strcpy(tmp, _str);
//				delete[] _str;
//				_str = tmp;
//				_capacity = n;
//			}
//		}
//	}
//	void string::pushback(char ch)
//	{
//		if (_size == _capacity)
//		{
//			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
//			reserve(newcapacity);
//		}
//		_str[_size] = ch;
//		_size++;
//		_str[_size] = '\0';
//
//
//		/*	if (_size == _capacity)
//			{
//				size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
//				reserve(newCapacity);
//			}
//
//			_str[_size] = ch;
//			_size++;
//			_str[_size] = '\0';*/
//	}
//	void string::append(const char* str)
//	{
//		size_t len = strlen(str);
//		//检查是否需要扩容
//		if (len + _size > _capacity)
//		{
//			reserve(_size + len);
//		}
//		strcpy(_str + _size, str);
//		_size += len;
//	}
//	string& string::operator+=(char c)
//	{
//		pushback(c);
//		return *this;
//	}
//	string& string::operator+=(const char* str)
//	{
//		append(str);
//		return *this;
//	}
//	string& string::operator=(const string& s)			//赋值是也注意浅拷贝问题！！！
//	{
//		char* tmp = new char[s._capacity + 1];
//		strcpy(tmp, s._str);
//		delete[] _str;
//		_str = tmp;
//		_capacity = s._capacity;
//		_size = s._size;
//		return *this;
//	}
//	void string::insert(size_t pos, char c)
//	{
//		assert(pos <= _size);
//		//检查容量
//		if (_size == _capacity)
//		{
//			size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
//			reserve(newcapacity);
//		}
//		//插入
//		size_t end = _size + 1;
//		while (end > pos)
//		{
//			_str[end] = _str[end - 1];
//			end--;
//		}
//		_str[pos] = c;
//		_size++;
//	}
//	void string::insert(size_t pos, const char* str)
//	{
//		assert(pos <= _size);
//		size_t len = strlen(str);
//		//检查是否需要扩容
//		if (len + _size > _capacity)
//		{
//			reserve(_size + len);
//		}
//		//插入
//		int end = _size;			//为什么要用int类型？size_t类型没有无法表示-1，如果pos为1，（end为size_t类型）则end--后，end为无无符号整型最大值，程序陷入死循环。
//
//		while (end >= (int)pos)		//为什么要强制类型转换？end（int）型与 （size_t型）pos比较时会发生隐式类型转换，会出现上述情况。
//		{
//			_str[end + len] = _str[end];
//			end--;
//		}
//		size_t i = 0;
//		/*while (i < len)
//		{
//			_str[pos + i] = str[i];
//			i++;
//		}*/
//		strncpy(_str + pos, str, len);
//		_size += len;
//	}
//	void string::erase(size_t pos, size_t len = std::string::npos)
//	{
//		assert(pos <= _size);
//		if (len == std::string::npos || pos + len > _size)
//		{
//			_str[pos] = '\0';
//			_size = pos;
//		}
//		else {
//			strcpy(_str + pos, _str + pos + len);
//			_size -= len;
//		}
//	}
//
//
//	void string::swap(string& s)
//	{
//		std::swap(_str, s._str);
//		std::swap(_capacity, s._capacity);
//		std::swap(_size, s._size);
//	}
//	size_t string::find(char c, size_t pos = 0)
//	{
//		assert(pos < _size);
//		for (size_t i = pos; i < _size; i++)
//		{
//			if (_str[i] == c)
//			{
//				return i;
//			}
//		}
//		return std::string::npos;
//
//	}
//	size_t string::find(const char* str, size_t pos)
//	{
//		assert(pos < _size);
//		const char* n = strstr(_str + pos, str);
//		if (n == nullptr)
//		{
//			return std::string::npos;
//		}
//		else
//		{
//			return n - _str;
//		}
//	}
//	string string::substr(size_t pos, size_t len = std::string::npos)		//pos起始位置，子串长度
//	{
//		assert(pos < _size);
//		size_t buff = pos;
//		if (len == std::string::npos || pos + len > _size)
//		{
//			buff = _size;
//		}
//		else {
//			buff = pos + len;
//		}
//		string str;
//		reserve(buff - pos);
//		//添加数据
//		while (pos <= buff)
//		{
//			str += _str[pos];
//			pos++;
//		}
//		return str;				//注意浅拷贝问题，返回的是str的拷贝，要调用拷贝构造函数，采用深拷贝来避免
//	}
//
//	//清空函数
//	void string::clear()
//	{
//		_size = 0;
//		_str[_size] = '\0';
//	}
//	ostream& operator<<(ostream& out, const string& s)
//	{
//		for (auto i : s)
//		{
//			out << i;
//		}
//		return out;
//	}
//	istream& operator>> (istream& in, string& s)
//	{
//		char buff[128];
//		char ch = in.get();
//		size_t i = 0;
//		while (ch != ' ' && ch != '\n')
//		{
//			buff[i++] = ch;
//			if (i == 127)
//			{
//				buff[i] = '\0';
//				s += buff;
//				i = 0;
//			}
//		
//		}
//		if (i != 0)
//		{
//			buff[i] = '\0';
//			s += buff;
//		}
//		return in;
//	}
//}
